14. Grails和Spring

Spring开发人员经常热衷于想知道Grails中的ApplicationContext实例是怎么创建的.基本过程如下：

配置Spring Beans

大部分Grails的配置都是在运行时进行. 每个插件都可以配置在上面创建的ApplicationContext对象中注册过的Spring bean. For a reference as to which beans are configured refer to the reference guide which describes each of the Grails plug-ins and which beans they configure.

14.2 配置其他Bean

使用XML

Beans可用过grails-app/conf/spring/resources.xml 来配置. 这个文件是一个标准的Spring配置文件，在Spring Spring参考文档中对如何配置Spring Beans有详细描述。下面是一个简单的例子:

<bean id="myBean" class="my.company.MyBeanImpl"></bean>

配置完毕后, myBean就可以在Grails 控制器，标签库，服务等很多地方引用：

class ExampleController {     def myBean
}

引用现有的Spring bean

在resources.xml中声明的bean也可以通过约定来引用Grails类 . 比如，如果你想在你的bean中引用 BookService这样一个service，你可以用如下的代码：

<bean id="myBean" class="my.company.MyBeanImpl">
        <property name="bookService" ref="bookService" />        
</bean>

package my.company
class MyBeanImpl {
        BookService bookService
}

package my.company;
class MyBeanImpl {
        private BookService bookService;
        public void setBookService(BookService theBookService) {
                this.bookService = theBookService;
        }
}

既然大部分Grails配置都是在运行时通过约定机制来完成，大部分bean并不需要声明, 但仍然可以在Spring应用中进行引用. 如你需要引用一个Grails DataSource 你可以这样:

<bean id="myBean" class="my.company.MyBeanImpl">
        <property name="bookService" ref="bookService" />        
        <property name="dataSource" ref="dataSource" />
</bean>

<bean id="myBean" class="my.company.MyBeanImpl">
        <property name="bookService" ref="bookService" />        
        <property name="sessionFactory" ref="sessionFactory" />
</bean>

使用Spring DSL

如果你想使用Grails提供的 Spring DSL ，你必须创建grails-app/conf/spring/resources.groovy 文件，定义一个 beans属性块:

beans = {
        // 定义的beans
}

beans = {
        myBean(my.company.MyBeanImpl) {
                bookService = ref("bookService")
        }  
}

这样做最大的好处是你能够在bean的定义中混合各种逻辑，如基于 environment:

import grails.util.*
beans = {
        switch(GrailsUtil.environment) {
                case "production":
                        myBean(my.company.MyBeanImpl) {
                                bookService = ref("bookService")
                        }           break
                case "development":
                        myBean(my.company.mock.MockImpl) {
                                bookService = ref("bookService")
                        }  
                break
        }  
}

14.3 运行时Spring与Beans DSL

这是因为Spring的常规配置方法（通过XML）在本质上是静态的，除了通过程序方式来动态产生XML配置文件外，很难在运行时修改和添加程序配置。而且这种方法非常繁琐，也容易出错. Grails的BeanBuilder 改变了这一点，它可以让你在运行时通过系统属性和环境属性来动态改变程序逻辑.

这使得程序代码动态适配它的环境，避免不必要的重复代码（如在Spring中为测试环境，开发环境和生产环境做不同的配置)

BeanBuilder 类

Grails提供了 grails.spring.BeanBuilder 类使用动态Groovy来创建bean的声明. 基本点如下:

import org.apache.commons.dbcp.BasicDataSource
import org.codehaus.groovy.grails.orm.hibernate.ConfigurableLocalSessionFactoryBean;
import org.springframework.context.ApplicationContext;def bb = new grails.spring.BeanBuilder()
bb.beans {
    dataSource(BasicDataSource) {
        driverClassName = "org.hsqldb.jdbcDriver"
        url = "jdbc:hsqldb:mem:grailsDB"
        username = "sa"
        password = ""
    }
    sessionFactory(ConfigurableLocalSessionFactoryBean) {
        dataSource = dataSource
        hibernateProperties = [ "hibernate.hbm2ddl.auto":"create-drop",
                                "hibernate.show_sql":true  ]
    }
}
ApplicationContext appContext = bb.createApplicationContext()

上面这个例子说明了如果使用 BeanBuilder类来配置某个特定的Hibernate数据源。

实际上，每个方法调用( dataSource 和 sessionFactory 调用) 都映射到Spring中的bean的名字. 方法的第一个参数是bean的class名字, 最后一个参数是一个块（block）. 在块内部可以用标准的Groovy语法设置bean的属性。

通过bean的名字自动查找bean的引用. 通过上面的sessionFactory bean解析dataSource可以看点这一点。

也可以通过builder设置一些与bean管理相关的特殊的bean属性，如：

sessionFactory(ConfigurableLocalSessionFactoryBean) { bean ->
    bean.autowire = 'byName'       // Autowiring behaviour. The other option is 'byType'. [autowire]
    bean.initMethod = 'init'       // Sets the initialisation method to 'init'. [init-method]
    bean.destroyMethod = 'destroy' // Sets the destruction method to 'destroy'. [destroy-method]
    bean.scope = 'request'         // Sets the scope of the bean. [scope]
    dataSource = dataSource
    hibernateProperties = [ "hibernate.hbm2ddl.auto":"create-drop",
                            "hibernate.show_sql":true  ]
}

在Spring MVC中使用BeanBuilder

如果想在Spring MVC中使用BeanBuilder，你必须确保grails-spring-<version>.jar 包含在classpath中. 还要在/WEB-INF/web.xml文件中做如下设置：

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationContext.groovy</param-value>
</context-param>
<context-param>
    <param-name>contextClass</param-name>
    <param-value>org.codehaus.groovy.grails.commons.spring.GrailsWebApplicationContext</param-value>
</context-param>

beans {
        dataSource(org.apache.commons.dbcp.BasicDataSource) {
        driverClassName = "org.hsqldb.jdbcDriver"
        url = "jdbc:hsqldb:mem:grailsDB"
        username = "sa"
        password = ""
    }
}

从文件系统中加载bean定义

你可以使用BeanBuilder并使用下面的语法来加载在外部Groovy脚本中定义的bean：

def bb = new BeanBuilder()
bb.loadBeans("classpath:*SpringBeans.groovy")def applicationContext = bb.createApplicationContext()

这里BeanBuilder 将加载在classpath中以SpringBeans.groovy结尾的Groovy文件并将它们解析成bean的定义.这里是一个范例脚本文件：

beans {
    dataSource(BasicDataSource) {
        driverClassName = "org.hsqldb.jdbcDriver"
        url = "jdbc:hsqldb:mem:grailsDB"
        username = "sa"
        password = ""
    }
    sessionFactory(ConfigurableLocalSessionFactoryBean) {
        dataSource = dataSource
        hibernateProperties = [ "hibernate.hbm2ddl.auto":"create-drop",
                                "hibernate.show_sql":true  ]
    }
}

绑定变量

如果从脚本中加载bean，可以通过创建Groovy Binding对象来实现绑定:

def binding = new Binding()
binding.foo = "bar"
def bb = new BeanBuilder()
bb.binding = binding
bb.loadBeans("classpath:*SpringBeans.groovy")
def ctx = bb.createApplicationContext()

14.4 BeanBuilder DSL

使用构建器参数

可以通过在bean的class和最后一个closure之间定义的方法来定义构建器参数:

bb.beans {
    exampleBean(MyExampleBean, "firstArgument", 2) {
        someProperty = [1,2,3]
    }
}

配置 BeanDefinition (使用工厂方法)

传给closure的第一个参数是一个bean配置对象引用,你可以使用它来配置工厂方法，调用 AbstractBeanDefinition 的方法:

bb.beans {
    exampleBean(MyExampleBean) { bean ->
        bean.factoryMethod = "getInstance"
        bean.singleton = false
        someProperty = [1,2,3]
    }
}

bb.beans {
    def example = exampleBean(MyExampleBean) {
        someProperty = [1,2,3]
    }
    example.factoryMethod = "getInstance"
}

使用工厂bean（Factory beans）

Spring提供了工厂bean的概念，即bean不是从class创建，而是由这些工厂创建 defines the concept of factory beans and often a bean is created not from a class, but from one of these factories. 在这种情况下bean没有class，你必须将工厂bean的名字传给定义的bean:

bb.beans {
    myFactory(ExampleFactoryBean) {
        someProperty = [1,2,3]
    }
    myBean(myFactory) {
        name = "blah"
    }
}

注意：上面的例子中我们传递的是 myFactory bean而不是一个clas. 另一个常见的需求是提供调用工厂bean的工厂方法名，可以用下面的Groovy语法做到这一点：

bb.beans {
    myFactory(ExampleFactoryBean) {
        someProperty = [1,2,3]
    }
    myBean(myFactory:"getInstance") {
        name = "blah"
    }
}

这里 ExampleFactoryBean 的 getInstance会被调用来创建myBean bean.

运行时创建 bean的引用

有时只有在运行是才知道需要创建的bean的名字. 在这种情况情况下你可以使用字符串替换来实现动态调用:

def beanName = "example"
bb.beans {
    "${beanName}Bean"(MyExampleBean) {
        someProperty = [1,2,3]
    }
}

另外, 可使用ref来动态引用在运行时才知道的bean的名字，如下面的代码：

def beanName = "example"
bb.beans {
    "${beanName}Bean"(MyExampleBean) {
        someProperty = [1,2,3]
    }
    anotherBean(AnotherBean) {
        example = ref("${beanName}Bean")
    }
}

这里AnotherBean属性通过运行时对 exampleBean的引用来设置 . 也可以通过 ref 来引用在父 ApplicationContext定义的bean， ApplicationContext在 BeanBuilder的构建器中提供:

ApplicationContext parent = ...//
der bb = new BeanBuilder(parent)
bb.beans {
    anotherBean(AnotherBean) {
        example = ref("${beanName}Bean", true)
    }
}

这里第二个参数 true 指定了在父ApplicationContext中查找bean的引用.

使用匿名内部bean

你可以通过将属性块付给bean的一个属性来使用匿名内部bean，这个属性块提供一个bean的类型参数:

bb.beans {
    marge(Person.class) {
        name = "marge"
        husband =  { Person p ->
            name = "homer"
            age = 45
            props = [overweight:true, height:"1.8m"]
        }
        children = [bart, lisa]
    }
    bart(Person) {
        name = "Bart"
        age = 11
    }
    lisa(Person) {
        name = "Lisa"
        age = 9
    }
}

在上面的例子中我们将marge bean的husband属性赋值一个属性块（参数类型是Person）的方式创建一个内部bean引用. 如果你有一个工厂bean你也可以忽略类型参数，直接使用传进进来的bean的定义：

bb.beans {
    personFactory(PersonFactory.class)
    marge(Person.class) {
        name = "marge"
        husband =  { bean ->
            bean.factoryBean = "personFactory"
            bean.factoryMethod = "newInstance"
            name = "homer"
            age = 45
            props = [overweight:true, height:"1.8m"]
        }
        children = [bart, lisa]
    }
}

抽象bean和父子bean定义

class HolyGrailQuest {
    def start() { println "lets begin" }
}
class KnightOfTheRoundTable {
    String name
    String leader
    KnightOfTheRoundTable(String n) {
        this.name = n
    }
    HolyGrailQuest quest    def embarkOnQuest() {
        quest.start()
    }
}
def bb = new grails.spring.BeanBuilder()
bb.beans {
    abstractBean {
        leader = "Lancelot"
    }
    …
}

这里定义了一个抽象bean，这个bean有一个属性 leader，属性值为 "Lancelot". 要使用抽象bean，只要将它设为要定义的bean的父即可：

bb.beans {
    …
    quest(HolyGrailQuest)
    knights(KnightOfTheRoundTable, "Camelot") { bean ->
        bean.parent = abstractBean
        quest = quest
    }
}

def bb = new grails.spring.BeanBuilder()
bb.beans {
    abstractBean(KnightOfTheRoundTable) { bean ->
        bean.'abstract' = true
        leader = "Lancelot"
    }
    quest(HolyGrailQuest)
    knights("Camelot") { bean ->
        bean.parent = abstractBean
        quest = quest
    }
}

上面例子中我们创建了抽象 KnightOfTheRoundTable 并将它的参数设为abstract. 接下来我们定义了一个knights bean，没有定义它的class，而是继承父bean中定义的class。

使用 Spring命名空间

从Spring 2.0开始，通过XML命名空间可以更方便的使用Spring的各种特性. 如果使用 BeanBuilder，你可以先声明所要使用的Spring命名空间:

xmlns context:"http://www.springframework.org/schema/context"

context.'component-scan'( 'base-package' :"my.company.domain" )

通过Spring的命名空间可以做很多有用的事，比如查找JNDI资源:

xmlns jee:"http://www.springframework.org/schema/jee"

jee.'jndi-lookup'(id:"dataSource", 'jndi-name':"java:comp/env/myDataSource")

上面的例子通过查找JNDI创建一个 dataSourcebean对象. 通过Spring命名空间，你可以在BeanBuilder中直接访问Spring AOP功能比如下面的代码:

class Person {
 int age;
 String name; void birthday() {
      ++age;
 }
}
class BirthdayCardSender {
   List peopleSentCards = []
   public void onBirthday(Person person) {
      peopleSentCards << person
   }
}

你可以定义一个AOP aspect pointcut来监测对 birthday() 方法的所有调用:

xmlns aop:"http://www.springframework.org/schema/aop"
fred(Person) { 
 name = "Fred" 
 age = 45 
}birthdayCardSenderAspect(BirthdayCardSender)
aop { 
   config("proxy-target-class":true) { 
       aspect( id:"sendBirthdayCard",ref:"birthdayCardSenderAspect" ) { 
          after method:"onBirthday", pointcut: "execution(void ..Person.birthday()) and this(person)" 
       } 
   } 
}

14.5 属性占位符配置

Settings defined in either ConfigSlurper scripts of Java properties files can be used as placeholder values for Spring configuration in grails-app/conf/spring/resources.xml. For example given the following entries in grails-app/conf/Config.groovy (or an externalized config):

database.driver="com.mysql.jdbc.Driver"
database.dbname="mysql:mydb"

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
   <property name="driverClassName"><value>${database.driver}</value></property>
   <property name="url"><value>jdbc:${database.dbname}</value></property>
 </bean>

14.6 属性重载

你可以提供一个 ConfigSlurper脚本文件，该文件中定义了一个 beans 属性块，属性块中定义的属性值会覆盖bean中定义的属性值:

beans {
   bookService.webServiceURL = "http://www.amazon.com"
}

[bean name].[property name] = [value]

你也可以提供一个常规的Java属性文件，属性文件中的每个条目加上beans前缀:

14. Grails和 Spring

14.1 Grails内部实现

Grails ApplicationContext